package member

import (
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"gopkg.in/gomail.v2"
	"strconv"
	"woo-server/coms/structs"
	"woo-server/coms/utils"
	"woo-server/models/api"
	"woo-server/models/db/member"
)

// 结构
type UserSvr struct {
	*structs.Common
}

// 初始化
func NewMemberService(com *structs.Common) *UserSvr {
	return &UserSvr{com}
}

// 当前用户信息
func (u *UserSvr) GetLoginUserInfo() *api.ResultEntity {
	type Animal struct {
		category string
	}
	//data := api.LoginUser{
	//	UserId: u.Claim.UserId,
	//	RoleId: u.Claim.RoleId,
	//	Name:   u.Claim.Name,
	//	Avatar: u.Claim.Avatar,
	//}
	uModel := member.NewMember(u.Common)
	uModel.MemberId = u.Claim.UserId
	data, err := uModel.First(true)
	if err != nil {
		api.Error(err.Error())
	}
	return api.SuccessToJson(data, "success")
}

// 添加用户信息
func (u *UserSvr) CreateUser() *api.ResultEntity {

	rsp := api.CreateUserRsp{}

	// 参数
	req, err := u.validationCreateUser()
	if err != nil {
		// 日志
		utils.LogError("CreateUser.validationCreateUser err:%s", err.Error())
		return api.BadRequestResultEntity(err.Error())
	}

	// 数据入库
	uModel := member.NewMember(u.Common)
	uModel.NickName = req.NickName
	uModel.Status = 1
	// 基础参数
	uModel.SetCreateInfo(u.Claim.UserId)

	// 执行创建
	err = uModel.Create()
	if err != nil {
		// 日志
		utils.LogError("CreateUser.Create err:%s", err.Error())
		return api.InternalErrorResultEntity(err.Error())
	}

	// 添加的ID
	rsp.ID = uModel.MemberId

	return api.SuccessToJson(utils.ToJson(&rsp), "添加用户成功!")
}

// 校验添加用户信息入参
func (u *UserSvr) validationCreateUser() (*structs.CreateMemberReq, error) {

	rsp := &structs.CreateMemberReq{}

	// Context
	context := u.Context

	// 参数
	MemberId := uint64(structs.SetInt(context.PostForm("MemberId")))

	// 内容为空
	if MemberId == 0 {
		return rsp, errors.New("缺少必要参数: MemberId")
	}
	// 参数
	NickName := context.PostForm("NickName")

	// 内容为空
	if len(NickName) == 0 {
		return rsp, errors.New("昵称不能为空")
	}
	rsp.Status = structs.SetInt(context.PostForm("Status"))
	rsp.NickName = NickName
	rsp.MemberId = MemberId
	rsp.GradeId = uint64(structs.SetInt(context.PostForm("GradeId")))
	rsp.Email = context.PostForm("Email")
	rsp.FileId = uint64(structs.SetInt(context.PostForm("FileId")))
	return rsp, nil
}

func (u *UserSvr) GetUserConfig() *api.ResultEntity {
	userConfig := member.NewMember(u.Common).GetUserConfig()
	return api.SuccessToJson(userConfig, "获取用户配置成功!")
}

func (u *UserSvr) UpdateUserInfo() *api.ResultEntity {
	userModel := member.NewMember(u.Common)
	req, err := u.validationCreateUser()
	if err != nil {
		return api.Error(err.Error())
	}

	userModel.MemberId = u.Claim.UserId
	userModel, fErr := userModel.First(false)
	if fErr != nil {
		return api.Error("非法操作!")
	}
	userModel.FileId = 0
	userModel.SetUpdateInfo(u.Claim.UserId)
	//userModel.MemberId = req.MemberId
	userModel.NickName = req.NickName
	userModel.Email = req.Email
	userModel.FileId = req.FileId
	fmt.Println(userModel)
	SaveErr := userModel.Save()
	if SaveErr != nil {
		return api.Error(SaveErr.Error())
	}
	return api.Success("个人资料更新成功!")
}

// 用户列表
func (u *UserSvr) GetList(context *gin.Context) *api.ResultEntity {

	search := context.Query("search")
	page := structs.SetInt(context.Query("page"))
	pageSize := structs.SetInt(context.Query("pageSize"))
	Model := member.NewMember(u.Common)
	list, total := Model.GetListAndTotal(search, page, pageSize)
	result := map[string]interface{}{"list": list, "total": total}
	return api.SuccessToJson(result, "用户列表获取成功!")
}

func (u *UserSvr) PostSave(context *gin.Context) *api.ResultEntity {
	userModel := member.NewMember(u.Common)
	req, err := u.validationCreateUser()
	if err != nil {
		return api.Error(err.Error())
	}

	userModel, fErr := userModel.First(false)
	if fErr != nil {
		return api.Error("非法操作!")
	}
	userModel.FileId = 0
	userModel.SetUpdateInfo(u.Claim.UserId)
	userModel.MemberId = req.MemberId
	userModel.NickName = req.NickName
	userModel.Email = req.Email
	userModel.FileId = req.FileId
	userModel.Status = req.Status
	fmt.Println(userModel)
	SaveErr := userModel.Save()
	if SaveErr != nil {
		return api.Error(SaveErr.Error())
	}
	if req.MemberId == 0 {
		// 基础参数
		userModel.SetCreateInfo(u.Claim.UserId)
		// 执行创建
		err = userModel.Create()
	} else {
		userModel.GradeId = req.GradeId
		userModel.SetUpdateInfo(u.Claim.UserId)
		err = userModel.Save()
	}
	if err != nil {
		// 日志
		utils.LogError("新增用户报错:%s", err.Error())
		return api.Error(err.Error())
	}
	return api.Success("success")
}

func (u *UserSvr) Delete(context *gin.Context) *api.ResultEntity {
	//context.Param()
	// 接收POST参数
	GradeId := context.PostForm("GradeId")
	// 校验参数
	if GradeId == "" {
		return api.Error("ID不能为空!")
	}
	if GradeId == "1" {
		api.Error("无法删除超级管理员")
	}
	// 实例化数据库
	Model := member.NewMember(u.Common)
	// 执行删除
	Model.GradeId = uint64(structs.SetInt(GradeId))
	// 删除数据
	err := Model.Delete()
	if err != nil {
		utils.LogError("删除用户报错:%s", err.Error())
		return api.Error(err.Error())
	}
	return api.Success("删除成功")
}

func (u *UserSvr) SendMail(mailTo []string, subject string, body string) error {
	//定义邮箱服务器连接信息，如果是网易邮箱 pass填密码，qq邮箱填授权码

	//mailConn := map[string]string{
	//  "user": "xxx@163.com",
	//  "pass": "your password",
	//  "host": "smtp.163.com",
	//  "port": "465",
	//}

	mailConn := map[string]string{
		"user": "colinwoo@colinwoo.com",
		"pass": "",
		"host": "smtp.ym.163.com",
		"port": "25",
	}

	port, _ := strconv.Atoi(mailConn["port"]) //转换端口类型为int

	m := gomail.NewMessage()

	m.SetHeader("From", m.FormatAddress(mailConn["user"], "ColinWoo")) //这种方式可以添加别名，即“XX官方”
	// 说明：如果是用网易邮箱账号发送，以下方法别名可以是中文，如果是qq企业邮箱，以下方法用中文别名，会报错，需要用上面此方法转码
	//m.SetHeader("From", "FB Sample"+"<"+mailConn["user"]+">") //这种方式可以添加别名，即“FB Sample”， 也可以直接用<code>m.SetHeader("From",mailConn["user"])</code> 读者可以自行实验下效果
	//m.SetHeader("From", mailConn["user"])
	m.SetHeader("To", mailTo...)    //发送给多个用户
	m.SetHeader("Subject", subject) //设置邮件主题
	m.SetBody("text/html", body)    //设置邮件正文

	d := gomail.NewDialer(mailConn["host"], port, mailConn["user"], mailConn["pass"])

	err := d.DialAndSend(m)
	return err

}
